package org.share.comm.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * 该类实现使一批多线程并行处理，并在所有线程都处理结束后，处理所有执行结果
 * 多线程并行处理，使用fixed线程池，线程池大小参看 org.share.comm.thread.ThreadPool.Fixed
 * 
 * 用法：
 * ParallelThread<T> thread = ParallelThread.newParallelThread();
 * //批量提交线程
 * for(int i=0; i<100; i++){
 * 	thread.submit(new Callable<T>(){
 * 		public T call() throws Exception{
 * 			//do something
 * 		}
 * 	});
 * }
 * //上面所有线程结束后执行该方法
 * thread.getResult(new ResultCallback<T>(){
 * 	public void deal(T t){
 * 		//do something
 * 	}
 * });
 * 
 * @author hhm
 *
 * @param <T>
 */
public class ParallelThread<T> {
	
	private List<Future<T>> futureList = new ArrayList<>();
	
	/**
	 * 创建并行处理线程
	 * @return
	 */
	public static <T> ParallelThread<T> newParallelThread(){
		return new ParallelThread<>();
	}
	
	/**
	 * 提交并行处理线程
	 * @param callable
	 */
	public void submit(Callable<T> callable){
		futureList.add(ThreadPool.Fixed.submit(callable));
	}
	
	/**
	 * 等待线程处理结束，执行结果回调处理
	 * @param callback
	 * @throws InterruptedException
	 * @throws ExecutionException
	 */
	public void getResult(ResultCallback<T> callback) throws InterruptedException, ExecutionException{
		if (futureList.size() > 0) {
			for (Future<T> future : futureList) {
				callback.deal(future.get());
			}
		}
	}
	
	/**
	 * 并行线程处理结束，处理结果处理回调接口
	 * @author hhm
	 *
	 * @param <T>
	 */
	@FunctionalInterface
	public interface ResultCallback<T>{
		void deal(T t);
	}
	
}
